IRIX Base Documentation 2001 May/SGI IRIX Base Documentation 2001 May.iso/usr/share/catman/p_man/cat3/perl5/IO::Select.z/IO::Select

Text File | 1998-10-30 | 5.7 KB | 199 lines

IIIIOOOO::::::::SSSSeeeelllleeeecccctttt((((3333))))                                                    IIIIOOOO::::::::SSSSeeeelllleeeecccctttt((((3333))))



NNNNAAAAMMMMEEEE
     IO::Select - OO interface to the select system call

SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
         use IO::Select;

         $s = IO::Select->new();

         $s->add(\*STDIN);
         $s->add($some_handle);

         @ready = $s->can_read($timeout);

         @ready = IO::Select->new(@handles)->read(0);


DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
     The IO::Select package implements an object approach to the system select
     function call. It allows the user to see what IO handles, see the
     _I_O::_H_a_n_d_l_e manpage, are ready for reading, writing or have an error
     condition pending.

CCCCOOOONNNNSSSSTTTTRRRRUUUUCCCCTTTTOOOORRRR
     new ( [ HANDLES ] )
         The constructor creates a new object and optionally initialises it
         with a set of handles.

MMMMEEEETTTTHHHHOOOODDDDSSSS
     add ( HANDLES )
         Add the list of handles to the IO::Select object. It is these values
         that will be returned when an event occurs. IO::Select keeps these
         values in a cache which is indexed by the fileno of the handle, so if
         more than one handle with the same fileno is specified then only the
         last one is cached.

         Each handle can be an IO::Handle object, an integer or an array
         reference where the first element is a IO::Handle or an integer.

     remove ( HANDLES )
         Remove all the given handles from the object. This method also works
         by the fileno of the handles. So the exact handles that were added
         need not be passed, just handles that have an equivalent fileno

     exists ( HANDLE )
         Returns a true value (actually the handle itself) if it is present.
         Returns undef otherwise.

     handles
         Return an array of all registered handles.






                                                                        PPPPaaaaggggeeee 1111






IIIIOOOO::::::::SSSSeeeelllleeeecccctttt((((3333))))                                                    IIIIOOOO::::::::SSSSeeeelllleeeecccctttt((((3333))))



     can_read ( [ TIMEOUT ] )
         Return an array of handles that are ready for reading. TIMEOUT is the
         maximum amount of time to wait before returning an empty list. If
         TIMEOUT is not given and any handles are registered then the call
         will block.

     can_write ( [ TIMEOUT ] )
         Same as can_read except check for handles that can be written to.

     has_error ( [ TIMEOUT ] )
         Same as can_read except check for handles that have an error
         condition, for example EOF.

     count ()
         Returns the number of handles that the object will check for when one
         of the can_ methods is called or the object is passed to the select
         static method.

     bits()
         Return the bit string suitable as argument to the core _s_e_l_e_c_t() call.

     bits()
         Return the bit string suitable as argument to the core _s_e_l_e_c_t() call.

     select ( READ, WRITE, ERROR [, TIMEOUT ] )
         select is a static method, that is you call it with the package name
         like new. READ, WRITE and ERROR are either undef or IO::Select
         objects. TIMEOUT is optional and has the same effect as for the core
         select call.

         The result will be an array of 3 elements, each a reference to an
         array which will hold the handles that are ready for reading, writing
         and have error conditions respectively. Upon error an empty array is
         returned.

EEEEXXXXAAAAMMMMPPPPLLLLEEEE
     Here is a short example which shows how IO::Select could be used to write
     a server which communicates with several sockets while also listening for
     more connections on a listen socket

         use IO::Select;
         use IO::Socket;













                                                                        PPPPaaaaggggeeee 2222






IIIIOOOO::::::::SSSSeeeelllleeeecccctttt((((3333))))                                                    IIIIOOOO::::::::SSSSeeeelllleeeecccctttt((((3333))))



         $lsn = new IO::Socket::INET(Listen => 1, LocalPort => 8080);
         $sel = new IO::Select( $lsn );

         while(@ready = $sel->can_read) {
             foreach $fh (@ready) {
                 if($fh == $lsn) {
                     # Create a new socket
                     $new = $lsn->accept;
                     $sel->add($new);
                 }
                 else {
                     # Process socket

                     # Maybe we have finished with the socket
                     $sel->remove($fh);
                     $fh->close;
                 }
             }
         }


AAAAUUUUTTTTHHHHOOOORRRR
     Graham Barr <_G_r_a_h_a_m._B_a_r_r@_t_i_u_k._t_i._c_o_m>

CCCCOOOOPPPPYYYYRRRRIIIIGGGGHHHHTTTT
     Copyright (c) 1995 Graham Barr. All rights reserved. This program is free
     software; you can redistribute it and/or modify it under the same terms
     as Perl itself.



























                                                                        PPPPaaaaggggeeee 3333